package com.anrong.wulansdk.sdk.db;

import java.util.Collection;
import java.util.List;

import com.anrong.orm.LiteOrm;
import com.anrong.orm.db.assit.QueryBuilder;
import com.anrong.orm.db.assit.WhereBuilder;
import com.anrong.orm.db.model.ColumnsValue;
import com.anrong.orm.db.model.ConflictAlgorithm;
import com.anrong.wulansdk.sdk.WLData;

import android.annotation.SuppressLint;
import android.content.Context;
import android.os.Environment;

/**
 * 数据库工具类
 * 
 *
 */
public class LiteOrmDBUtil {

	public static String DB_NAME;
	private static LiteOrm liteOrm;
	public static Context mContext;

	/**
	 * 数据库名称
	 * 
	 * @return
	 */
	private static String getDatabaseName() {
		//数据库位置
		return Environment.getExternalStorageDirectory().getAbsolutePath()+"/wlsdk/wl_info";
//		return "wl_info";
	}

	/**
     * 创建数据库细节 ：
     * 细节一：每次启动都会调用这个方法，是否会重复创建，或者说怎么判断这个数据库已经存在。
     * 回答：尽在第一次创建，开发这不用关心存在否。
     * 
     * 细节二：如果指定目录创建在SD卡上，卸载APP之后，重新安装，以前的创建的数据库还存在
     * 回答：如果不想这样，就不要指定创建在SD卡上面，默认创建就在APP里。卸载后数据库就不存在了
     * 
     * 细节三：创建数据库有两种模式，第一种是单一操作没有级联关系的，第二种是级联操作。
     * 创建单一操作模式：LiteOrm.newSingleInstance(_activity, DB_NAME);
     * 创建级联操作模式：LiteOrm.newCascadeInstance(_activity, DB_NAME);
	 * @param context
	 */
	public static synchronized boolean createCascadeDB(Context context) {
		mContext = context.getApplicationContext();
		
		liteOrm = getLiteOrm();
		liteOrm.setDebugged(true);
//		liteOrm.setDebugged(WLData.getConfig().getshowLog());
		return true;
	}

	public static synchronized LiteOrm getLiteOrm() {
		if (liteOrm == null) {
			if (mContext == null) {
				return null;
			}
			liteOrm = LiteOrm.newCascadeInstance(mContext, getDatabaseName());
		}
		return liteOrm;
	}

	/**
	 * 插入一条记录
	 * 
	 * @param t
	 */
	public static <T> long insert(T t) {
		return getLiteOrm().save(t);
	}

	/**
	 * 插入所有记录
	 * 
	 * @param list
	 */
	public static <T> int insertAll(List<T> list) {
		return getLiteOrm().save(list);
	}

	/**
	 * 以某种条件作为插入标准
	 * 
	 * @param list
	 * @return
	 */
	public static <T> long insertAll(Collection<T> t, ConflictAlgorithm config) {
		return getLiteOrm().insert(t, config);
	}

	/**
	 * 以某种条件作为插入标准
	 * 
	 * @param list
	 * @return
	 */
	public static <T> long insertAll(List<T> t, ConflictAlgorithm config) {
		return getLiteOrm().insert(t, config);
	}

	/**
	 * 查询所有
	 * 
	 * @param cla
	 * @return
	 */
	public static <T> List<T> getQueryAll(Class<T> cla) {
		return getLiteOrm().query(cla);
	}
	
	/**
	 * 查询数量
	 * @param cla
	 * @return
	 */
	public static <T> long getCount(Class<T> cla){
		return getLiteOrm().queryCount(cla);
	}

	/**
	 * 根据ID查询
	 * 
	 * @param cla
	 * @return
	 */
	public static <T> T getInfoById(String id, Class<T> cla) {
		return getLiteOrm().queryById(id, cla);
	}

	/**
	 * 根据ID查询
	 * 
	 * @param cla
	 * @return
	 */
	public static <T> T getInfoById(long id, Class<T> cla) {
		return getLiteOrm().queryById(id, cla);
	}

	/**
	 * 查询 某字段 等于 Value的值
	 * 
	 * @param cla
	 * @param field
	 * @param value
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static <T> List<T> getQueryByWhere(Class<T> cla, String field,
			String[] value) {
		return getLiteOrm().<T> query(
				new QueryBuilder(cla).where(field + "=?", value));
	}

	/**
	 * 查询 某字段 等于 Value的值 可以指定从1-20，就是分页
	 * 
	 * @param cla
	 * @param field
	 * @param value
	 * @param start
	 * @param length
	 * @return
	 */
	public static <T> List<T> getQueryByWhereLength(Class<T> cla, String field,
			String[] value, int start, int length) {
		return getLiteOrm().<T> query(
				new QueryBuilder(cla).where(field + "=?", value).limit(start,
						length));
	}

	/**
	 * 删除所有 某字段等于 Vlaue的值
	 * 
	 * @param cla
	 * @param field
	 * @param value
	 */
	@SuppressWarnings("deprecation")
	public static <T> int deleteWhere(Class<T> cla, String field, String[] value) {
		// liteOrm.delete(cla, WhereBuilder.create().where(field + "=?",
		// value));
		return getLiteOrm().delete(cla,
				WhereBuilder.create(cla, field + "=?", value));
	}

	/**
	 * 删除所有
	 * 
	 * @param cla
	 */
	public static <T> int deleteAll(Class<T> cla) {
		return getLiteOrm().deleteAll(cla);
	}

	/**
	 * 仅在以存在时更新
	 * 
	 * @param t
	 */
	public static <T> int update(T t) {
		return getLiteOrm().update(t, ConflictAlgorithm.Replace);
	}

	/**
	 * 以某种条件来整体更新
	 * 
	 * @param list
	 * @param config
	 * @return
	 */
	public static <T> int updateAll(List<T> list, ConflictAlgorithm config) {
		return getLiteOrm().update(list, config);
	}

	public static <T> int updateALL(List<T> list) {
		return getLiteOrm().update(list);
	}

	public static <T> void update(Class<T> cla, String queryCol,
			String queryValue, String updateCol, String updateValue) {
		getLiteOrm().update(
				new WhereBuilder(cla).where(queryCol + " = ?",
						new String[] { queryValue }),
				new ColumnsValue(new String[] { updateCol },
						new Object[] { updateValue }), ConflictAlgorithm.None);

	}

	@SuppressLint("NewApi")
	public void closeDB() {
		if (liteOrm != null) {
			liteOrm.close();
		}
	}

	// public static void Text(){
	//
	// //我们把这个对象当做以填充数据的后的对象
	// Conversation mConversation = new Conversation();
	//
	// List<Conversation> list = new ArrayList<Conversation>();
	// for (int i = 0; i < 10; i++) {
	// list.add(mConversation);
	// }
	//
	//
	// //1、插入单条数据
	// LiteOrmDBUtil.insert(mConversation);
	//
	// //2、插入多条数据
	// LiteOrmDBUtil.insertAll(list);
	//
	// //3、查询Conversation表中所有记录
	// List<Conversation> list = LiteOrmDBUtil.getQueryAll(Conversation.class);
	//
	// //4、查询Conversation表中 isVisibility 字段 等于 true 的记录
	// List<Conversation> list =
	// LiteOrmDBUtil.getQueryByWhere(Conversation.class,
	// Conversation.ISVISIBILITY, new String[]{"true"});
	//
	// //5、查询Conversation表中 isVisibility 字段 等于 true 的记录,并且只取20条
	// List<Conversation> list =
	// LiteOrmDBUtil.getQueryByWhereLength(Conversation.class,
	// Conversation.ISVISIBILITY, new String[]{"true"},0,20);
	//
	// //6、删除Conversation表中 isVisibility 字段 等于 true 的记录
	// LiteOrmDBUtil.deleteWhere(Conversation.class,Conversation.ISVISIBILITY ,
	// new String[]{"true"});
	//
	// //7、删除所有
	// LiteOrmDBUtil.deleteAll(Conversation.class);
	//
	//
	// }

}